{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5a172e1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d5d2bc77",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using PyTorch version: 1.13.1+cu117  Device: cuda\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "    \n",
    "print('Using PyTorch version:', torch.__version__, ' Device:', device)\n",
    "\n",
    "\n",
    "#1.load data\n",
    "#TODO 进行数据增强跑起来试试看！！！\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "batch_size = 128\n",
    "\n",
    "#这是已经划分好训练和测试数据集了的\n",
    "trainset = torchvision.datasets.CIFAR100(root='./cifar-100-python', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "testset = torchvision.datasets.CIFAR100(root='./cifar-100-python', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = {19: 'cattle', 29: 'dinosaur', 0: 'apple', 11: 'boy', 1: 'aquarium_fish', 86: 'telephone',\n",
    "           90: 'train', 28: 'cup', 23: 'cloud', 31: 'elephant', 39: 'keyboard', 96: 'willow_tree', \n",
    "           82: 'sunflower', 17: 'castle', 71: 'sea', 8: 'bicycle', 97: 'wolf', 80: 'squirrel', \n",
    "           74: 'shrew', 59: 'pine_tree', 70: 'rose', 87: 'television', 84: 'table', 64: 'possum', \n",
    "           52: 'oak_tree', 42: 'leopard', 47: 'maple_tree', 65: 'rabbit', 21: 'chimpanzee', \n",
    "           22: 'clock', 81: 'streetcar', 24: 'cockroach', 78: 'snake', 45: 'lobster', 49: 'mountain', \n",
    "           56: 'palm_tree', 76: 'skyscraper', 89: 'tractor', 73: 'shark', 14: 'butterfly', 9: 'bottle', \n",
    "           6: 'bee', 20: 'chair', 98: 'woman', 36: 'hamster', 55: 'otter', 72: 'seal', 43: 'lion', 51: 'mushroom', \n",
    "           35: 'girl', 83: 'sweet_pepper', 33: 'forest', 27: 'crocodile', 53: 'orange', 92: 'tulip', 50: 'mouse', \n",
    "           15: 'camel', 18: 'caterpillar', 46: 'man', 75: 'skunk', 38: 'kangaroo', 66: 'raccoon', 77: 'snail', \n",
    "           69: 'rocket', 95: 'whale', 99: 'worm', 93: 'turtle', 4: 'beaver', 61: 'plate', 94: 'wardrobe', 68: 'road', \n",
    "           34: 'fox', 32: 'flatfish', 88: 'tiger', 67: 'ray', 30: 'dolphin', 62: 'poppy', 63: 'porcupine', 40: 'lamp', \n",
    "           26: 'crab', 48: 'motorcycle', 79: 'spider', 85: 'tank', 54: 'orchid', 44: 'lizard', 7: 'beetle', 12: 'bridge', \n",
    "           2: 'baby', 41: 'lawn_mower', 37: 'house', 13: 'bus', 25: 'couch', 10: 'bowl', 57: 'pear', 5: 'bed', \n",
    "           60: 'plain', 91: 'trout', 3: 'bear', 58: 'pickup_truck', 16: 'can'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a687d74c",
   "metadata": {},
   "source": [
    "## 2. Define a ResNet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "242a1ec2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "454c52f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from https://github.com/bubbliiiing/yolov4-tiny-pytorch\n",
    "class CA_Block(nn.Module):\n",
    "    def __init__(self, channel, reduction=16):\n",
    "        super(CA_Block, self).__init__()\n",
    "        \n",
    "        self.conv_1x1 = nn.Conv2d(in_channels=channel, out_channels=channel//reduction, kernel_size=1, stride=1, bias=False)\n",
    " \n",
    "        self.relu   = nn.ReLU()\n",
    "        self.bn     = nn.BatchNorm2d(channel//reduction)\n",
    " \n",
    "        self.F_h = nn.Conv2d(in_channels=channel//reduction, out_channels=channel, kernel_size=1, stride=1, bias=False)\n",
    "        self.F_w = nn.Conv2d(in_channels=channel//reduction, out_channels=channel, kernel_size=1, stride=1, bias=False)\n",
    " \n",
    "        self.sigmoid_h = nn.Sigmoid()\n",
    "        self.sigmoid_w = nn.Sigmoid()\n",
    " \n",
    "    def forward(self, x):\n",
    "        _, _, h, w = x.size()\n",
    "        \n",
    "        x_h = torch.mean(x, dim = 3, keepdim = True).permute(0, 1, 3, 2)\n",
    "        x_w = torch.mean(x, dim = 2, keepdim = True)\n",
    " \n",
    "        x_cat_conv_relu = self.relu(self.bn(self.conv_1x1(torch.cat((x_h, x_w), 3))))\n",
    " \n",
    "        x_cat_conv_split_h, x_cat_conv_split_w = x_cat_conv_relu.split([h, w], 3)\n",
    " \n",
    "        s_h = self.sigmoid_h(self.F_h(x_cat_conv_split_h.permute(0, 1, 3, 2)))\n",
    "        s_w = self.sigmoid_w(self.F_w(x_cat_conv_split_w))\n",
    " \n",
    "        out = x * s_h.expand_as(x) * s_w.expand_as(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d6435cb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#残差块\n",
    "#TODO 看具体残差块含义\n",
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, in_channel, out_channel, stride=1):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channel, out_channel, kernel_size=3,\n",
    "                               stride=stride, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channel)\n",
    "        self.conv2 = nn.Conv2d(out_channel, out_channel, kernel_size=3,\n",
    "                               stride=1, padding=1, bias=False)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channel)\n",
    "        self.shortcut = nn.Sequential()\n",
    "\n",
    "        if stride != 1 or in_channel != self.expansion * out_channel:\n",
    "            self.shortcut = nn.Sequential(\n",
    "                nn.Conv2d(in_channel, self.expansion * out_channel,\n",
    "                          kernel_size=1, stride=stride, bias=False),\n",
    "                nn.BatchNorm2d(self.expansion * out_channel)\n",
    "            )\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        out += self.shortcut(x)\n",
    "        out = F.relu(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6b30d168",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (layer1): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential()\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential()\n",
      "    )\n",
      "  )\n",
      "  (layer2): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential(\n",
      "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential()\n",
      "    )\n",
      "  )\n",
      "  (layer3): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential(\n",
      "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential()\n",
      "    )\n",
      "  )\n",
      "  (layer4): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential(\n",
      "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (shortcut): Sequential()\n",
      "    )\n",
      "  )\n",
      "  (CA): Sequential(\n",
      "    (0): CA_Block(\n",
      "      (conv_1x1): Conv2d(512, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "      (relu): ReLU()\n",
      "      (bn): BatchNorm2d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (F_h): Conv2d(1, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "      (F_w): Conv2d(1, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "      (sigmoid_h): Sigmoid()\n",
      "      (sigmoid_w): Sigmoid()\n",
      "    )\n",
      "  )\n",
      "  (linear): Linear(in_features=512, out_features=100, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, block, num_blocks, num_classes=100):\n",
    "        super(Net, self).__init__()\n",
    "        self.in_channel = 64\n",
    "\n",
    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,\n",
    "                               stride=1, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(64)\n",
    "\n",
    "        self.layer1 = self.make_layer(block, 64, num_blocks[0], stride=1)\n",
    "        self.layer2 = self.make_layer(block, 128, num_blocks[1], stride=2)\n",
    "        self.layer3 = self.make_layer(block, 256, num_blocks[2], stride=2)\n",
    "        self.layer4 = self.make_layer(block, 512, num_blocks[3], stride=2)\n",
    "        self.CA = self.make_CA(512)\n",
    "        self.linear = nn.Linear(512 * block.expansion, num_classes)\n",
    "\n",
    "    def make_layer(self, block, out_channel, num_blocks, stride):\n",
    "        strides = [stride] + (num_blocks - 1) * [1]\n",
    "        layers = []\n",
    "        for stride in strides:\n",
    "            layers.append(block(self.in_channel, out_channel, stride))\n",
    "            self.in_channel = out_channel * block.expansion\n",
    "        return nn.Sequential(*layers)\n",
    "    \n",
    "    def make_CA(self, out_channel):\n",
    "        layers = []\n",
    "        layers.append(CA_Block(self.in_channel, out_channel))\n",
    "        self.in_channel = out_channel * 1\n",
    "        return nn.Sequential(*layers)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.layer1(out)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        out  = self.CA(out)\n",
    "        out = F.avg_pool2d(out, 4)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        out = self.linear(out)\n",
    "        return out\n",
    "\n",
    "#超参都可以改！！！\n",
    "def ResNet():\n",
    "    return Net(BasicBlock, [2, 2, 2,2])#4个残差块？？？\n",
    "\n",
    "\n",
    "net = ResNet().to(device)\n",
    "print(net)\n",
    "\n",
    "#一些超参\n",
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e493e029",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50000\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for data, target in trainloader:\n",
    "    target = target.to(device)\n",
    "    total += target.size(0)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a9329e77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,    50] loss: 4.592\n",
      "[1,   100] loss: 4.531\n",
      "[1,   150] loss: 4.490\n",
      "[1,   200] loss: 4.445\n",
      "[1,   250] loss: 4.387\n",
      "[1,   300] loss: 4.349\n",
      "[1,   350] loss: 4.301\n",
      "\n",
      "Validation set: Average loss: 0.0335, Accuracy: 683/10000 (7%)\n",
      "\n",
      "[2,    50] loss: 4.233\n",
      "[2,   100] loss: 4.126\n",
      "[2,   150] loss: 4.012\n",
      "[2,   200] loss: 3.914\n",
      "[2,   250] loss: 3.799\n",
      "[2,   300] loss: 3.778\n",
      "[2,   350] loss: 3.713\n",
      "\n",
      "Validation set: Average loss: 0.0289, Accuracy: 1333/10000 (13%)\n",
      "\n",
      "[3,    50] loss: 3.603\n",
      "[3,   100] loss: 3.601\n",
      "[3,   150] loss: 3.550\n",
      "[3,   200] loss: 3.505\n",
      "[3,   250] loss: 3.463\n",
      "[3,   300] loss: 3.442\n",
      "[3,   350] loss: 3.411\n",
      "\n",
      "Validation set: Average loss: 0.0266, Accuracy: 1858/10000 (19%)\n",
      "\n",
      "[4,    50] loss: 3.294\n",
      "[4,   100] loss: 3.254\n",
      "[4,   150] loss: 3.199\n",
      "[4,   200] loss: 3.167\n",
      "[4,   250] loss: 3.122\n",
      "[4,   300] loss: 3.135\n",
      "[4,   350] loss: 3.094\n",
      "\n",
      "Validation set: Average loss: 0.0243, Accuracy: 2411/10000 (24%)\n",
      "\n",
      "[5,    50] loss: 2.989\n",
      "[5,   100] loss: 2.956\n",
      "[5,   150] loss: 2.942\n",
      "[5,   200] loss: 2.962\n",
      "[5,   250] loss: 2.871\n",
      "[5,   300] loss: 2.848\n",
      "[5,   350] loss: 2.787\n",
      "\n",
      "Validation set: Average loss: 0.0227, Accuracy: 2837/10000 (28%)\n",
      "\n",
      "[6,    50] loss: 2.652\n",
      "[6,   100] loss: 2.680\n",
      "[6,   150] loss: 2.718\n",
      "[6,   200] loss: 2.669\n",
      "[6,   250] loss: 2.617\n",
      "[6,   300] loss: 2.637\n",
      "[6,   350] loss: 2.596\n",
      "\n",
      "Validation set: Average loss: 0.0210, Accuracy: 3262/10000 (33%)\n",
      "\n",
      "[7,    50] loss: 2.452\n",
      "[7,   100] loss: 2.458\n",
      "[7,   150] loss: 2.470\n",
      "[7,   200] loss: 2.406\n",
      "[7,   250] loss: 2.430\n",
      "[7,   300] loss: 2.384\n",
      "[7,   350] loss: 2.397\n",
      "\n",
      "Validation set: Average loss: 0.0198, Accuracy: 3707/10000 (37%)\n",
      "\n",
      "[8,    50] loss: 2.180\n",
      "[8,   100] loss: 2.187\n",
      "[8,   150] loss: 2.179\n",
      "[8,   200] loss: 2.201\n",
      "[8,   250] loss: 2.219\n",
      "[8,   300] loss: 2.226\n",
      "[8,   350] loss: 2.154\n",
      "\n",
      "Validation set: Average loss: 0.0194, Accuracy: 3618/10000 (36%)\n",
      "\n",
      "[9,    50] loss: 1.943\n",
      "[9,   100] loss: 1.912\n",
      "[9,   150] loss: 2.006\n",
      "[9,   200] loss: 1.977\n",
      "[9,   250] loss: 1.964\n",
      "[9,   300] loss: 1.963\n",
      "[9,   350] loss: 1.928\n",
      "\n",
      "Validation set: Average loss: 0.0182, Accuracy: 4058/10000 (41%)\n",
      "\n",
      "[10,    50] loss: 1.674\n",
      "[10,   100] loss: 1.675\n",
      "[10,   150] loss: 1.717\n",
      "[10,   200] loss: 1.727\n",
      "[10,   250] loss: 1.707\n",
      "[10,   300] loss: 1.751\n",
      "[10,   350] loss: 1.749\n",
      "\n",
      "Validation set: Average loss: 0.0180, Accuracy: 4184/10000 (42%)\n",
      "\n",
      "[11,    50] loss: 1.423\n",
      "[11,   100] loss: 1.413\n",
      "[11,   150] loss: 1.464\n",
      "[11,   200] loss: 1.434\n",
      "[11,   250] loss: 1.519\n",
      "[11,   300] loss: 1.508\n",
      "[11,   350] loss: 1.547\n",
      "\n",
      "Validation set: Average loss: 0.0184, Accuracy: 4331/10000 (43%)\n",
      "\n",
      "[12,    50] loss: 1.133\n",
      "[12,   100] loss: 1.210\n",
      "[12,   150] loss: 1.268\n",
      "[12,   200] loss: 1.243\n",
      "[12,   250] loss: 1.304\n",
      "[12,   300] loss: 1.272\n",
      "[12,   350] loss: 1.247\n",
      "\n",
      "Validation set: Average loss: 0.0190, Accuracy: 4131/10000 (41%)\n",
      "\n",
      "[13,    50] loss: 0.894\n",
      "[13,   100] loss: 0.950\n",
      "[13,   150] loss: 0.971\n",
      "[13,   200] loss: 0.993\n",
      "[13,   250] loss: 1.039\n",
      "[13,   300] loss: 1.069\n",
      "[13,   350] loss: 1.100\n",
      "\n",
      "Validation set: Average loss: 0.0201, Accuracy: 4233/10000 (42%)\n",
      "\n",
      "[14,    50] loss: 0.661\n",
      "[14,   100] loss: 0.733\n",
      "[14,   150] loss: 0.895\n",
      "[14,   200] loss: 0.832\n",
      "[14,   250] loss: 0.833\n",
      "[14,   300] loss: 0.795\n",
      "[14,   350] loss: 0.816\n",
      "\n",
      "Validation set: Average loss: 0.0217, Accuracy: 4364/10000 (44%)\n",
      "\n",
      "[15,    50] loss: 0.469\n",
      "[15,   100] loss: 0.541\n",
      "[15,   150] loss: 0.550\n",
      "[15,   200] loss: 0.601\n",
      "[15,   250] loss: 0.651\n",
      "[15,   300] loss: 0.627\n",
      "[15,   350] loss: 0.672\n",
      "\n",
      "Validation set: Average loss: 0.0240, Accuracy: 4265/10000 (43%)\n",
      "\n",
      "[16,    50] loss: 0.351\n",
      "[16,   100] loss: 0.352\n",
      "[16,   150] loss: 0.401\n",
      "[16,   200] loss: 0.466\n",
      "[16,   250] loss: 0.473\n",
      "[16,   300] loss: 0.524\n",
      "[16,   350] loss: 0.547\n",
      "\n",
      "Validation set: Average loss: 0.0245, Accuracy: 4196/10000 (42%)\n",
      "\n",
      "[17,    50] loss: 0.265\n",
      "[17,   100] loss: 0.329\n",
      "[17,   150] loss: 0.365\n",
      "[17,   200] loss: 0.395\n",
      "[17,   250] loss: 0.446\n",
      "[17,   300] loss: 0.416\n",
      "[17,   350] loss: 0.433\n",
      "\n",
      "Validation set: Average loss: 0.0273, Accuracy: 4300/10000 (43%)\n",
      "\n",
      "[18,    50] loss: 0.238\n",
      "[18,   100] loss: 0.276\n",
      "[18,   150] loss: 0.255\n",
      "[18,   200] loss: 0.258\n",
      "[18,   250] loss: 0.637\n",
      "[18,   300] loss: 0.599\n",
      "[18,   350] loss: 0.480\n",
      "\n",
      "Validation set: Average loss: 0.0262, Accuracy: 4229/10000 (42%)\n",
      "\n",
      "[19,    50] loss: 0.245\n",
      "[19,   100] loss: 0.256\n",
      "[19,   150] loss: 0.240\n",
      "[19,   200] loss: 0.316\n",
      "[19,   250] loss: 0.296\n",
      "[19,   300] loss: 0.264\n",
      "[19,   350] loss: 0.282\n",
      "\n",
      "Validation set: Average loss: 0.0283, Accuracy: 4321/10000 (43%)\n",
      "\n",
      "[20,    50] loss: 0.149\n",
      "[20,   100] loss: 0.161\n",
      "[20,   150] loss: 0.232\n",
      "[20,   200] loss: 0.195\n",
      "[20,   250] loss: 0.359\n",
      "[20,   300] loss: 0.262\n",
      "[20,   350] loss: 0.248\n",
      "\n",
      "Validation set: Average loss: 0.0280, Accuracy: 4381/10000 (44%)\n",
      "\n",
      "Training Finished\n"
     ]
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "#注意注意注意： 每次运行这里时 先把前面的above都运行一遍！！！--》即使值改动了epoch 前面的也得执行一遍！！！\n",
    "def validate(loss_vector, accuracy_vector):\n",
    "    net.eval()\n",
    "    total = 0\n",
    "    val_loss, correct = 0, 0\n",
    "    for data, target in testloader:\n",
    "        data = data.to(device)\n",
    "        target = target.to(device)\n",
    "        output = net(data)\n",
    "        val_loss += criterion(output, target).data.item()\n",
    "        _, predicted = torch.max(output.data, 1)\n",
    "        correct += (predicted == target).sum().item()\n",
    "        total += target.size(0)#total就是一个 总数...\n",
    "\n",
    "    val_loss /= total\n",
    "    loss_vector.append(val_loss)\n",
    "\n",
    "    accuracy = 100 * correct / total\n",
    "    accuracy_vector.append(accuracy)\n",
    "\n",
    "    print('\\nValidation set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "        val_loss, correct, total, accuracy))\n",
    "       \n",
    "#开始训练 \n",
    "lossv, accv = [], []\n",
    "\n",
    "epochs = 20#可调整--这里可以变成train函数\n",
    "#train\n",
    "for epoch in range(epochs):  # loop over the dataset multiple times\n",
    "    \n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        if i % 50 == 49:    # print every 50 mini-batches\n",
    "            print(f'[{epoch+1}, {i+1:5d}] loss: {running_loss / 50:.3f}')\n",
    "            running_loss = 0.0\n",
    "    validate(lossv, accv)\n",
    "print('Training Finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecf62cce",
   "metadata": {},
   "source": [
    "Let’s quickly save our trained model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9d94a16d",
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = './cifar_net.pth'\n",
    "torch.save(net.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4c60ea6a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'validation accuracy,epoch=20')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.figure(figsize=(5,3))\n",
    "plt.plot(np.arange(1,epochs+1), lossv)\n",
    "plt.title('validation loss,epoch=%s'%epochs)\n",
    "\n",
    "plt.figure(figsize=(5,3))\n",
    "plt.plot(np.arange(1,epochs+1), accv)\n",
    "plt.title('validation accuracy,epoch=%s'%epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "909e084f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
